package com.bms.client.service.impl;

import com.bms.client.pojo.LunWen;
import com.bms.client.mapper.LunWenMapper;
import com.sun.deploy.net.URLEncoder;
import org.springframework.stereotype.Service;
import com.bms.client.service.LunWenService;
import org.springframework.util.ResourceUtils;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.*;

/**
 * 论文管理与检索表(LunWen)表服务实现类
 *
 * @author godmaker
 * @since 2021-03-16 15:49:16
 * @version 1.0
 */
@Service("lunWenService")
public class LunWenServiceImpl implements LunWenService {
    @Resource
    private LunWenMapper lunWenMapper;
//    @Resource
//    private MyFileDownLoad myFileDownLoad;
//    private HttpServletRequest request;
//    private HttpServletResponse response;

    public LunWenServiceImpl() {
        super();
    }

    @Override
    public Map<String, Object> shanChuById(String id) {
        Map<String, Object> map = new HashMap<>();
        this.lunWenMapper.shanChuById(id);
        map.put("code", 200);
        map.put("msg", "删除成功");
        return map;
    }

    /**
     * 根据模糊条件查询总个数
     *
     * @return 返回查询到的总个数
     */
    @Override
    public Map<String, Object> chaXunCount(int index) {
        Map<String, Object> map = new HashMap<>();
        // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
        map.put("code", 200);
        map.put("msg", "查询成功");
        map.put("list", this.lunWenMapper.chaXunCount(index));
        return map;
    }


    /**
     * 根据模糊条件查询总个数
     *
     * @return 返回查询到的总个数
     */
    @Override
    public Map<String, Object> chaXunCount01(int index, String tiMu, String zuoZhe,
                                             String faBiaoWeiZhi, String lunWenLeiBie,
                                             String faBiaoShiJianQiShi, String faBiaoShiJianJieShu) {
        Map<String, Object> map = new HashMap<>();
        // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
        map.put("code", 200);
        map.put("msg", "查询成功");
        map.put("list", this.lunWenMapper.chaXunCount01(index, tiMu, zuoZhe, faBiaoWeiZhi, lunWenLeiBie,
                faBiaoShiJianQiShi, faBiaoShiJianJieShu));
        return map;
    }


    /**
     * 查询所有数据
     *
     * @return 返回所有数据
     */
    @Override
    public Map<String, Object> chaXunAll() {
        Map<String, Object> map = new HashMap<>();
        LunWen lunWen = new LunWen();
        // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
        map.put("code", 200);
        map.put("msg", "查询成功");
        map.put("list", this.lunWenMapper.chaXunAll());
//        String diZhi = ((LunWen)this.lunWenMapper.chaXunAll()).getLunWenFile();
        return map;
    }


    public Map<String, Object> chaXunById(int id) {
        Map<String, Object> map = new HashMap<>();
        // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
        map.put("code", 200);
        map.put("msg", "通过id查询附件地址成功");
        map.put("list", this.lunWenMapper.chaXunById(id));
        String dizhi = ((LunWen) this.lunWenMapper.chaXunById(id)).getLunWenFile();
        return map;
    }

    public Map<String,Object> xiaZai(HttpServletRequest request, HttpServletResponse response, String diZhi) {
// 需要传过来一个文件地址(数据库里的文件地址  String diZhi)
//        String fileName = request.getParameter("fileName"); //    fileName=video/test.wmv
        String fileName = diZhi;
//        Object userID = request.getSession().getAttribute("username");
//        if(userID == null) {
//            response.getWriter().println("ni yao deng lu");
//            return;
//        }
        Map<String,Object> map =new HashMap<>();
        if (fileName != null && !fileName.trim().equals("")) {
//            String wuLiLuJing = request.getServletContext().getRealPath(File.separator);//有问题定位在web文件下
            String wuLiLuJing = null;
            try {
                wuLiLuJing = ResourceUtils.getURL("classpath:").getPath() + "/static";
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
            // E:\IdeaProjects\zonghe\out\artifacts\zonghe_war_exploded\myfile\PLC_Server.rar
            System.out.println("wuLiLuJing=" + wuLiLuJing);
            File file = new File(wuLiLuJing + File.separator + fileName);
            System.out.println(file);
            try {
                // 查找服务器物理路径所在位置

                if (file.exists()) {
                    FileInputStream fis = new FileInputStream(file);
                    String filename = URLEncoder.encode(file.getName(), "utf-8"); // 解决中文文件名下载后乱码的问题
                    byte[] b = new byte[fis.available()];
                    fis.read(b);
                    response.setCharacterEncoding("UTF-8");
                    response.setHeader("Content-Disposition", "attachment; filename=" + filename + "");
                    response.setHeader("code","200");
                    response.setHeader("msg","success");
                    //获取响应报文输出流对象
                    ServletOutputStream out = response.getOutputStream();
                    //输出
                    map.put("code",200);
                    map.put("msg","success");
                    out.write(b);
                    out.flush();
                    out.close();
//                    return;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
        System.out.println(map);
        return  map;
    }


    /**
     * 查询所有数据
     *
     * @return 返回所有数据
     */
    @Override
    public Map<String, Object> chaXunCaoGao(int page) {
        Map<String, Object> map = new HashMap<>();
        // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
        map.put("code", 200);
        map.put("msg", "查询成功");
//        map.put("pageCount", pageCount);  // 查询的记录总页码
//        map.put("count", tableCount);     // 当前表中的总条数
        map.put("list", this.lunWenMapper.chaXunCaoGao((page - 1) * 5));
        map.put("count",this.lunWenMapper.chaXunCount(page));
        return map;
    }

    /**
     * 通过ID查询单条数据
     *
     * @param lunWenLeiBie 主键
     * @return 实例对象
     */
    @Override
    public Map<String, Object> chaXunByLeiBie(String lunWenLeiBie) {
        Map<String, Object> map = new HashMap<>();
        // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
        map.put("code", 200);
        map.put("msg", "查询成功");
        map.put("obj", this.lunWenMapper.chaXunByLeiBie(lunWenLeiBie));
        return map;
    }


    /**
     * 查询分页数据
     *
     * @param page                      查询起始位置
     * @param  page 查询条数
     * @return 对象列表
     */
    @Override
    public Map<String, Object> chaXunFenYe(int page) {
        // 获取当前表中的总记录
        int tableCount = this.lunWenMapper.chaXunCount(page);
        // 总页码计算   (总条数 - 1) / 每页显示条数  + 1
        // (100 - 1) / 10 + 1 = 10        (101 - 1) / 10 + 1 = 11      (99 - 1) / 10 + 1 = 10
        int pageCount = (tableCount - 1) / 5 + 1;
        // 计算每页开始的下标值
        int xiaBiao = (page - 1) * 5;
        Map<String, Object> map = new HashMap<>();
        map.put("code", 0);   // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
        map.put("msg", "查询成功");
        map.put("pageCount", pageCount);  // 查询的记录总页码
        map.put("count", tableCount);     // 当前表中的总条数
        map.put("data", this.lunWenMapper.chaXunFenYe(xiaBiao));
        return map;
    }


    /**
     * 查询分页数据
     *
     * @param page  查询起始位置
     * @param tiMu, zuoZhe,faBiaoWeiZhi,lunWenLeiBie,
     *              faBiaoShiJianQiShi,faBiaoShiJianJieShu 查询条数
     * @return 对象列表
     */
    @Override
    public Map<String, Object> chaXunFenYe01(int page, String tiMu, String zuoZhe,
                                             String faBiaoWeiZhi, String lunWenLeiBie,
                                             String faBiaoShiJianQiShi, String faBiaoShiJianJieShu) {
        // 获取当前表中的总记录
        int tableCount = this.lunWenMapper.chaXunCount01(page, tiMu, zuoZhe, faBiaoWeiZhi, lunWenLeiBie,
                faBiaoShiJianQiShi, faBiaoShiJianJieShu);
        // 总页码计算   (总条数 - 1) / 每页显示条数  + 1
        // (100 - 1) / 10 + 1 = 10        (101 - 1) / 10 + 1 = 11      (99 - 1) / 10 + 1 = 10
        int pageCount = (tableCount - 1) / 5 + 1;
        // 计算每页开始的下标值
        int xiaBiao = (page - 1) * 5;
        Map<String, Object> map = new HashMap<>();
        map.put("code", 0);   // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
        map.put("msg", "查询成功");
        map.put("pageCount", pageCount);  // 查询的记录总页码
        map.put("count", tableCount);     // 当前表中的总条数
        map.put("data", this.lunWenMapper.chaXunFenYe01(xiaBiao, tiMu, zuoZhe, faBiaoWeiZhi, lunWenLeiBie,
                faBiaoShiJianQiShi, faBiaoShiJianJieShu));
        return map;
    }
//文件上传的
//    public List<String> upLoad(HttpServletRequest request, MultipartFile[] files,String dir) throws IOException {
//        String realPath = request.getSession().getServletContext().getRealPath("/"+dir);
//        File upLoad = new File(realPath);
//        if (!upLoad.exists()){
//            upLoad.mkdirs();
//        }
//        List<String> list = new ArrayList<>();
//        for (int i = 0; i < files.length; i++) {
//            String filename = files[i].getOriginalFilename();
//            String serverPath = System.currentTimeMillis() + filename;
//            files[i].transferTo(new File(realPath, serverPath));
//            list.add("/"+dir+"/"+serverPath);
//        }
//        return list;


    /**
     * 新增数据
     *
     * @param lunWen 实例对象
     * @return 实例对象
     */
    @Override
    public Map<String, Object> xinZeng(LunWen lunWen, HttpServletRequest request,MultipartFile file) {
        // UUID.randomUUID()  返回内容：asd21321-ewrewrew213213-123213zsad-123asdasd这样的形态
        UUID uuid = UUID.randomUUID();//新增没有上传id所以使用uuid
        Map<String, Object> map = new HashMap<>();
        String suffix = "";
        String fileName = "";
//        if(file !=null && file.length>0) {

//        for (MultipartFile multipartFile : file) {
            if (null != file && !file.isEmpty()) {
                // 组装文件存储路径（绝对路径）  例如： /touXiangImg/idValue/
                suffix = File.separator + "lunWen" + File.separator + uuid + File.separator;//大文件夹名需要改，id或者uuid给到小文件名，防止文件名串了造成混乱
                // c:/tomcat/target/webapp
                // c:/tomcat/target/webapp/touXiangImg/idValue/
                String path = null;
//                String path = "\\lunWen\\";
                try {
                    path = ResourceUtils.getURL("classpath:").getPath() + "/static" + suffix;
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                }
                System.out.println("path=" + path);
                // 获取原文件名
                fileName = file.getOriginalFilename();
//                fileName = file[i].getOriginalFilename();
                System.out.println("文档名字：" + fileName);
                // 创建文件实例
                // c:/tomcat/target/webapp/touXiangImg/idValue/one.png
                File filePath = new File(path, fileName);
                System.out.println("上传地址：" + filePath);
                // 如果文件目录不存在，创建目录
                if (!filePath.getParentFile().exists()) {
                    filePath.getParentFile().mkdirs();
                    System.out.println("创建目录");
                }
                // 写入文件
//                try {
//                    file.transferTo(filePath);
//                    if ("未发表".equals(lunWen.getZhuangTai())) {
//                        String lunWenFile = suffix + fileName;
//                        lunWen.setLunWenFile(lunWenFile);
//                        lunWenMapper.xinZeng(lunWen);
//                        map.put("code", 200);
//                        map.put("msg", "保存论文成功");
//                        map.put("id", lunWen.getId());//新增后将此条新增的数据的id返回给前端
//                        map.put("lunWen", lunWen);
//                        return map;
//                    }else {
//                        String lunWenFile = suffix + fileName;
//                        lunWen.setLunWenFile(lunWenFile);
//                        lunWenMapper.xinZeng(lunWen);
//                        map.put("code", 200);   // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
//                        map.put("msg", "发表论文成功");
////                        map.put("id", lunWen.getId());//新增后将此条新增的数据的id返回给前端
//                        map.put("lunWen", lunWen);
//                        return map;
//                    }
//                    } catch (IOException e) {
//                        e.printStackTrace();
//                    }

                try {
                    file.transferTo(filePath);

                    String lunWenFile = suffix + fileName;
                    lunWen.setLunWenFile(lunWenFile);
                    lunWenMapper.xinZeng(lunWen);

                    map.put("code", 200);
                    map.put("msg", "发表论文成功");
                    map.put("lunWen", lunWen);
                    //                        map.put("id", lunWen.getId());
                    return map;
                } catch (IOException e) {
                    e.printStackTrace();
                    map.put("code", 500);
                    map.put("msg", "发表论文失败，");
                    return map;
                }
            }
                    if ("未发表".equals(lunWen.getZhuangTai())) {
                        String lunWenFile = suffix + fileName;
                        lunWen.setLunWenFile(lunWenFile);
                        lunWenMapper.xinZeng(lunWen);
                        map.put("code", 200);   // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
                        map.put("msg", "保存论文成功");
                        map.put("id", lunWen.getId());//新增后将此条新增的数据的id返回给前端
                        map.put("lunWen", lunWen);
                        return map;
                    } else if ("已发表".equals(lunWen.getZhuangTai())) {
                        String lunWenFile = suffix + fileName;
                        lunWen.setLunWenFile(lunWenFile);
                        lunWenMapper.xinZeng(lunWen);
                        map.put("code", 200);   // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
                        map.put("msg", "论文发表成功");
//                        map.put("id", lunWen.getId());
                        map.put("lunWen", lunWen);
                        return map;
                    }

            return map;
    }





//            if (
//                    "未发表".equals(lunWen.getZhuangTai())) {
//                String lunWenFile = suffix + fileName;
//                lunWen.setLunWenFile(lunWenFile);
//                lunWenMapper.xinZeng(lunWen);
//                map.put("code", 200);   // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
//                map.put("msg", "保存论文成功");
//                map.put("id", lunWen.getId());
////                map.put("list",this.lunWenMapper.chaXunCaoGao(int page));
//                return map;
//            } else if ("已发表".equals(lunWen.getZhuangTai())) {
//                String lunWenFile = suffix + fileName;
//                lunWen.setLunWenFile(lunWenFile);
//                lunWenMapper.xinZeng(lunWen);
//                map.put("code", 200);   // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
//                map.put("msg", "论文发表成功");
//                map.put("id", lunWen.getId());
//                return map;
//            }
//
//        return map;
//    }



    /**
     * 新增数据
     *
     * @param lunWen 实例对象
     * @return 实例对象
     */
//    @Override
//    public Map<String, Object> xinZeng(LunWen lunWen, HttpServletRequest request,MultipartFile file) {
//        // UUID.randomUUID()  返回内容：asd21321-ewrewrew213213-123213zsad-123asdasd这样的形态
//        UUID uuid = UUID.randomUUID();//新增没有上传id所以使用uuid
//        Map<String, Object> map = new HashMap<>();
//        String suffix = "";
//        String fileName = "";
////        if(file !=null && file.length>0){
//
////            for (MultipartFile multipartFile : file) {
//                if (null != file && !file.isEmpty()) {
//                    // 组装文件存储路径（绝对路径）  例如： /touXiangImg/idValue/
//                    suffix = File.separator + "lunWen" + File.separator + uuid + File.separator;//大文件夹名需要改，id或者uuid给到小文件名，防止文件名串了造成混乱
//                    // c:/tomcat/target/webapp
//                    // c:/tomcat/target/webapp/touXiangImg/idValue/
//                    String path = null;
////                String path = "\\lunWen\\";
//                    try {
//                        path = ResourceUtils.getURL("classpath:").getPath() + "/static" + suffix;
//                    } catch (FileNotFoundException e) {
//                        e.printStackTrace();
//                    }
//                    System.out.println("path=" + path);
//                    // 获取原文件名
//                    fileName = file.getOriginalFilename();
////                fileName = file[i].getOriginalFilename();
//                    System.out.println("文档名字：" + fileName);
//                    // 创建文件实例
//                    // c:/tomcat/target/webapp/touXiangImg/idValue/one.png
//                    File filePath = new File(path, fileName);
//                    System.out.println("上传地址：" + filePath);
//                    // 如果文件目录不存在，创建目录
//                    if (!filePath.getParentFile().exists()) {
//                        filePath.getParentFile().mkdirs();
//                        System.out.println("创建目录");
//                    }
//                    // 写入文件
//                    try {
//                        file.transferTo(filePath);
//
//                        String lunWenFile = suffix + fileName;
//                        lunWen.setLunWenFile(lunWenFile);
//                        lunWenMapper.xinZeng(lunWen);
//                        map.put("code", 200);
//                        map.put("msg", "发表论文成功");
//                        map.put("lunWen", lunWen);
////                lunWenMapper.shanChuById(lunWen.getId());
//                        return map;
//                    } catch (IOException e) {
//                        e.printStackTrace();
//                    }
//                }
//                if (
//                        "未发表".equals(lunWen.getZhuangTai())) {
//                    String lunWenFile = suffix + fileName;
//                    lunWen.setLunWenFile(lunWenFile);
//                    lunWenMapper.xinZeng(lunWen);
//                    map.put("code", 200);   // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
//                    map.put("list", lunWen.getId());
//                    map.put("msg", "保存论文成功");
//                    map.put("count",this.lunWenMapper.chaXunCaoGao(int page));
//                    return map;
//                } else if ("已发表".equals(lunWen.getZhuangTai())) {
//                    String lunWenFile = suffix + fileName;
//                    lunWen.setLunWenFile(lunWenFile);
//                    lunWenMapper.xinZeng(lunWen);
//                    map.put("code", 200);   // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
//                    map.put("msg", "论文发表成功");
//                    return map;
//                }
//            }
//






    /**
     * 编辑数据
     *
     * @param lunWen 实例对象
     * @return 实例对象
     */
    @Override
    public Map<String, Object> gengXinById(LunWen lunWen, HttpServletRequest request, MultipartFile file) {
        // UUID.randomUUID()  返回内容：asd21321-ewrewrew213213-123213zsad-123asdasd这样的形态
        UUID uuid = UUID.randomUUID();//新增没有上传id所以使用uuid
        Map<String, Object> map = new HashMap<>();
        String suffix = "";
        String fileName = "";
//        for (MultipartFile multipartFile : file) {
            if (file != null && !file.isEmpty()) {
                // 组装文件存储路径（绝对路径）  例如： /touXiangImg/idValue/
                suffix = File.separator + "lunWen" + File.separator + uuid + File.separator;//大文件夹名需要改，id或者uuid给到小文件名，防止文件名串了造成混乱
                // c:/tomcat/target/webapp
                // c:/tomcat/target/webapp/touXiangImg/idValue/
                String path = null;
                try {
                    path = ResourceUtils.getURL("classpath:").getPath() + "/static" + suffix;
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                }
                System.out.println("path=" + path);
                // 获取原文件名
                fileName = file.getOriginalFilename();
                System.out.println("文档名字：" + fileName);
                // 创建文件实例
                // c:/tomcat/target/webapp/touXiangImg/idValue/one.png
                File filePath = new File(path, fileName);
                System.out.println("上传地址：" + filePath);
                // 如果文件目录不存在，创建目录
                if (!filePath.getParentFile().exists()) {
                    filePath.getParentFile().mkdirs();
                    System.out.println("创建目录");
                }
                // 写入文件
                try {
                    file.transferTo(filePath);

                    String lunWenFile = suffix + fileName;
                    lunWen.setLunWenFile(lunWenFile);
                    lunWenMapper.gengXinById(lunWen);
//                    map.put("code", 200);
//                    map.put("msg", "保存论文成功");
                    map.put("lunWen", lunWen);
                    return map;
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if ("未发表".equals(lunWen.getZhuangTai())) {

                String lunWenFile = suffix + fileName;
                lunWen.setLunWenFile(lunWenFile);
                lunWenMapper.gengXinById(lunWen);
                map.put("code", 200);   // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
                map.put("msg", "论文保存成功");
                //                        map.put("id", lunWen.getId());
                return map;
            } else if ("已发表".equals(lunWen.getZhuangTai())) {
                String lunWenFile = suffix + fileName;
                lunWen.setLunWenFile(lunWenFile);
                lunWenMapper.gengXinById(lunWen);
                map.put("code", 200);   // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
                map.put("msg", "论文发表成功");
                return map;
            }
            return map;
    }






    @Override
    public Map<String, Object> lianHeChaXun(
            int page,
            String tiMu, String zuoZhe,
            String faBiaoWeiZhi, String lunWenLeiBie,
            String faBiaoShiJianQiShi, String faBiaoShiJianJieShu
    ) {
//        LunWen lunWen = new LunWen();
//        if ("已发表".equals(lunWen.getZhuangTai())){
        int index = (page - 1) * 5;//这里是每一页固定显示多少条
        Map<String, Object> map = new HashMap<>();
        map.put("code", 0);
        map.put("msg", "查询论文表数据成功");
        map.put("data", lunWenMapper.lianHeChaXun(index, tiMu, zuoZhe, faBiaoWeiZhi, lunWenLeiBie,
                faBiaoShiJianQiShi, faBiaoShiJianJieShu));
//        返回给前端一个总记录数count，用于分页
        map.put("count", lunWenMapper.chaXunCount01(index, tiMu, zuoZhe,
                faBiaoWeiZhi, lunWenLeiBie,
                faBiaoShiJianQiShi, faBiaoShiJianJieShu));

        return map;

    }

}